package com.hunan.yllxy.util;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @Author: 刘华
 * @Date: 2024/2/20 0020 11:51
 * @Version 1.0
 */
public class StringUtils {

    public static boolean isNotNull(String str) {
        boolean b = false;
        if (str != null && !"".equalsIgnoreCase(str.trim())) {
            b = true;
        }
        return b;
    }

    public static boolean isNotNull(Object object) {
        boolean b = false;
        if (object != null && !"".equalsIgnoreCase(object.toString().trim())) {
            b = true;
        }
        return b;
    }

    public static String toFixedString(Double doubleValue, int scale) {
        BigDecimal bd = new BigDecimal(Double.toString(doubleValue));
        bd = bd.setScale(scale, RoundingMode.HALF_UP);
        return bd.toString();
    }

    public static boolean isNull(Object object) {
        boolean b = false;
        if (object == null || "".equalsIgnoreCase(object.toString().trim())) {
            b = true;
        }
        return b;
    }


    public static boolean isNull(String str) {
        boolean b = false;
        if (str == null || "".equalsIgnoreCase(str.trim())) {
            b = true;
        }
        return b;
    }

    public static boolean isNull(Double d) {
        boolean b = false;
        if (d == null) {
            b = true;
        }
        return b;
    }

    public synchronized static boolean isNotNull(List str) {
        boolean b = false;
        if (str != null && !str.isEmpty()) {
            b = true;

        }
        return b;
    }
    public synchronized static boolean isNotNull(Map str) {
        boolean b = false;
        if (str != null && !str.isEmpty()) {
            b = true;

        }
        return b;
    }

    public synchronized static boolean isNull(Map str) {
        boolean b = false;
        if (str == null || str.isEmpty()) {
            b = true;
        }
        return b;
    }

    public static boolean isNull(List str) {
        boolean b = false;
        if (str == null || str.isEmpty()) {
            b = true;
        }
        return b;
    }

    public static boolean isNull(Set str) {
        boolean b = false;
        if (str == null || str.isEmpty()) {
            b = true;
        }
        return b;
    }

    public static boolean isNotNullObjStr(Object str) {
        boolean b = false;
        if (str != null && !"".equalsIgnoreCase(str.toString().trim())) {
            b = true;
        }
        return b;
    }

    public static boolean isNumeric(String str) {
        for (int i = str.length(); --i >= 0; ) {
            if (!Character.isDigit(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    /**
     * 将驼峰式命名的字符串转换为下划线大写方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。
     * 例如：HelloWorld->HELLO_WORLD
     *
     * @param name 转换前的驼峰式命名的字符串
     * @return 转换后下划线大写方式命名的字符串
     */
    private static String underscoreName(String name) {
        StringBuilder result = new StringBuilder();
        if (name != null && name.length() > 0) {
            // 将第一个字符处理成大写
            result.append(name.substring(0, 1).toUpperCase());
            // 循环处理其余字符
            for (int i = 1; i < name.length(); i++) {
                String s = name.substring(i, i + 1);
                // 在大写字母前添加下划线
                if (s.equals(s.toUpperCase()) && !Character.isDigit(s.charAt(0))) {
                    result.append("_");
                }
                // 其他字符直接转成大写
                result.append(s.toUpperCase());
            }
        }
        return result.toString();
    }

    /**
     * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。  * 例如：HELLO_WORLD->HelloWorld
     *
     * @param name 转换前的下划线大写方式命名的字符串
     * @return 转换后的驼峰式命名的字符串
     */
    public static String camelName(String name) {
        StringBuilder result = new StringBuilder();
        // 快速检查
        if (name == null || name.isEmpty()) {
            // 没必要转换
            return "";
        } else if (!name.contains("_")) {
            // 不含下划线，仅将首字母小写
            return name.substring(0, 1).toLowerCase() + name.substring(1);
        }
        // 用下划线将原始字符串分割
        String camels[] = name.split("_");
        for (String camel : camels) {
            // 跳过原始字符串中开头、结尾的下换线或双重下划线
            if (camel.isEmpty()) {
                continue;
            }
            // 处理真正的驼峰片段
            if (result.length() == 0) {
                // 第一个驼峰片段，全部字母都小写
                result.append(camel.toLowerCase());
            } else {
                // 其他的驼峰片段，首字母大写
                result.append(camel.substring(0, 1).toUpperCase());
                result.append(camel.substring(1).toLowerCase());
            }
        }
        return result.toString();
    }


    public static String removeUtf8Bom(String input) {
        if (input == null || input.length() < 3) {
            return input; // 如果字符串为空或长度小于3，直接返回
        }

        // 获取字符串的前三个字节的整数表示
        byte[] bytes = input.getBytes(StandardCharsets.UTF_8);
        if (bytes[0] == (byte) 0xEF && bytes[1] == (byte) 0xBB && bytes[2] == (byte) 0xBF) {
            // 如果前三个字节是UTF-8 BOM，则去除它们并返回新的字符串
            return new String(bytes, 3, bytes.length - 3, StandardCharsets.UTF_8);
        }

        // 如果不是UTF-8 BOM，则返回原始字符串
        return input;
    }
}
